/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package vigas.calculos;

/**
 *
 * @author Mateus
 */
public class VigaBalancoExtremidade implements DiagramaEsforco{

    double E;			// Módulo da elasticidade
    double I;			// Momento de inércia
    double L;			// Comprimento da viga
    int numPoints;		// Número de pontos a serem calculados
    int i;
    double A = 0, B = 10;
    // vetores para armazenamento de distância, cisalhamento, momento e deflexão (y)
    public double x[];          // distância da extremidade esquerda da viga
    public double v[];          // força cortante
    public double y[];          // deflexão
    public double m[];          // momento
    public double rr1;          // reação no apoio esquerdo
    public double rr2;          // reação no apoio direito

    public void setPosicaoSegundoApoio(double posicao){
        B = posicao;
    }

    public VigaBalancoExtremidade(double E,double I,double L,int n)
    {
        this.L = L;
        this.E = E;
        this.I = I;
        this.numPoints=n;
        x = new double[n];
        inicializarVetores(numPoints);
        for (i=0;i<numPoints;++i)
                x[i]=(double)i*L/((double)numPoints-1.);

    }

    private void inicializarVetores(int n){

        v = new double[n];
        m = new double[n];
        y = new double[n];

    }

    public void calcularEsforcosCargaDistribuida(double w1, double w2, double a, double b) {

        double l2; // comprimento da viga em balanço
        double l1; // comprimento da viga em apoio
        inicializarVetores(numPoints);
        l1 = B - A;
        l2 = L - l1;
        
        
        if (a >= l1 && b > l1) // Carga apenas na viga em balanço
        //TESTADO - CONFERE
        {
            
            rr2 = (w1*(b-a)/l1)*(a + (b-a)/2);
            rr1 = w1*(b-a) - rr2;

            for (i=0;i<numPoints;++i)
            {
                if (x[i]<=l1)
                {
                    v[i] = rr1;
                    m[i] = -(rr1*x[i]);
                }
                else if (l1 < x[i] && x[i] <= a)
                {
                    v[i] = rr1 + rr2;
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1));
                }
                else if (a < x[i] && x[i] <= b)
                {
                    v[i] = rr1 + rr2 - w1*(x[i]-a);
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1) - (w1*(x[i] - a)*(x[i]-(a + (x[i] - a)/2 ))));
                }
                else if (b < x[i] && x[i] <= L)
                {
                    v[i] = rr1 + rr2 - w1*(b-a);
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1) - (w1*(b-a)*(x[i]-(a + (b-a)/2))));
                }

            }

        }
        if (a < l1 && b <= l1) // Carga apenas na viga em apoio simples
        //TESTADO - CONFERE
        {

            rr2 = (w1*(b-a)/l1)*(a + (b-a)/2);
            rr1 = w1*(b-a) - rr2;
            
            for (i=0;i<numPoints;++i)
            {
                if (x[i] <= a)
                {
                    v[i] = rr1;
                    m[i] = -(rr1*x[i]);
                }
                else if (a < x[i] && x[i] <= b)
                {
                    v[i] = rr1 - w1*(x[i]-a);
                    m[i] = -(rr1*x[i] - w1*Math.pow(x[i]-a, 2)/2);
                }
                else if (b < x[i] && x[i] <= l1)
                {
                    v[i] = rr1 - w1*(b-a);
                    m[i] = -(rr1*x[i] - w1*(b-a)*(x[i] - (a + (b-a)/2)));
                }
                else if (l1 < x[i] && x[i] <= L)
                {
                    v[i] = rr1 + rr2 - w1*(b-a);
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1) - w1*(b-a)*(x[i] - (a + (b-a)/2)));
                }
            }
        }
        if(a <= l1 && b >= l1) // Carga distribuída entre as duas vigas
        //TESTADO - CONFERE
        {
            rr2 = (w1*(b-a)/l1)*(a + (b-a)/2);
            rr1 = w1*(b-a) - rr2;
            
            for (i=0;i<numPoints;++i)
            {
                
                if(x[i] <= a)
                {
                    v[i] = rr1;
                    m[i] = -(rr1*x[i]);
                }
                else if (a < x[i] && x[i] <= l1)
                {
                    v[i] = rr1 - w1*(x[i]-a);
                    m[i] = -(rr1*x[i] - w1*(x[i]-a)*(x[i]-(a + (x[i]-a)/2)));
                    //m[i] = -(rr1*x[i] - w1*(x[i]-a)*(x[i]-a)/2);
                }
                else if (l1 < x[i] && x[i] <= b)
                {
                    v[i] = rr1 + rr2 - w1*(x[i]-a);
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1) - w1*(x[i]-a)*(x[i]-(a + (x[i]-a)/2)));
                }
                else if (b < x[i] && x[i] <= L)
                {
                    v[i] = rr1 + rr2 - w1*(x[i]-a);
                    m[i] = rr1*x[i] + rr2*(x[i]-l1) - w1*(b-a)*(x[i]-(a + (b-a)/2));
                }
            }
        }

    }

    public void calcularEsforcosCargaConcentrada(double w, double a) {

        double l2; // comprimento da viga em balanço
        double l1; // comprimento da viga em apoio

        l1 = B - A;
        l2 = L - l1;
        inicializarVetores(numPoints);
        rr1 = w*(l1-a)/l1;
        rr2 = w*a/l1;


        if (a < l1) // Carga pontual na viga em apoio
        {
            for (i=0;i<numPoints;++i)
            {
                if (x[i] < a)
                {
                    v[i] = rr1;
                    m[i] = -(rr1*x[i]);
                }
                else if (a < x[i] && x[i] <= l1)
                {
                    v[i] = rr1 - w;
                    m[i] = -(rr1*x[i] - w*(x[i]-a));
                }
                else
                {
                    v[i] = rr1 + rr2 - w;
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1) - w*(x[i]-a));
                }
            }
        }
        if(a >= l1) // Carga pontual na viga em balanço
        {
            for (i=0;i<numPoints;++i)
            {
                if (x[i]<=l1)
                {
                    v[i] = rr1;
                    m[i] = -(rr1*x[i]);
                }
                else if (l1 < x[i] && x[i] <= a)
                {
                    v[i] = rr1 + rr2;
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1));
                }
                else if (a < x[i] && x[i] <= L)
                {
                    v[i] = rr1 + rr2 - w;
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1) - w*(x[i]-a));
                }
            }

        }

    }

    public void calcularEsforcosMomentoConcentrado(double mo, double a) {

        double l2; // comprimento da viga em balanço
        double l1; // comprimento da viga em apoio
        inicializarVetores(numPoints);
        l1 = B - A;
        l2 = L - l1;

        rr1 = -mo/l1;
        rr2 = -rr1;

        if(a<l1){ // Cálculo para momento concentrado na viga em apoio simples
            for (i=0;i<numPoints;++i)
            {
                if(x[i]<=a)
                {
                    v[i] = rr1;
                    m[i] = -(rr1*x[i]);
                }
                else if (a<x[i] && x[i]<=l1)
                {
                    v[i] = rr1;
                    m[i] = -(rr1*x[i] + mo);
                }
                else if (l1 < x[i] && x[i] <= L)
                {
                    v[i] = rr1 + rr2;
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1) + mo);
                }
            }
        }
        else if (a >= l1) // Cálculo para momento concentrado na viga em balanço
        {
            for (i=0;i<numPoints;++i)
            {
                if(x[i]<=l1)
                {
                    v[i] = rr1;
                    m[i] = -(rr1*x[i]);
                }
                else if (l1<x[i] && x[i]<=a)
                {
                    v[i] = rr1 + rr2;
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1));
                }
                else if (a < x[i] && x[i] <= L)
                {
                    v[i] = rr1 + rr2;
                    m[i] = -(rr1*x[i] + rr2*(x[i]-l1) + mo);
                }

            }
        }


    }

    public double[] getM() {
        return m;
    }

    public double[] getV() {
        return v;
    }


}